package com.czm.test;
import java.util.*;

public class Day06 {
    public static void main(String[] args) {
//        test068();
//        test067();
//        test066();
//        test065();
//        test();
//        test064();
//        test063();
//        test063_2();
//        test061();
//        test061_2();
//        test060();
//        test059();
//        test058();
//        test058_2();
//        test056();
//        String s1 = "ddacz";
//        String s2 = "dbddz";
//        char[] chars1 = s1.toCharArray();
//        char[] chars2 = s2.toCharArray();
//        System.out.println(s1.compareTo(s2));
//        int sum1 = 0;
//        int sum2 = 0;
//        for (int i = 0; i < chars1.length; i++) {
//            sum1 = sum1 + chars1[i];
//            sum2 = sum2 + chars2[i];
//        }
//        System.out.println(sum1 - sum2);
//        test055_2();

//        String a = "e ea b c d";
//        String[] split1 = a.split(" ");
//        for (int i = 0; i < split1.length; i++) {
//            System.out.print(split1[i] + " ");
//        }
//        System.out.println();
//        String[] split2 = a.split("\\s+");
//        for (int i = 0; i < split2.length; i++) {
//            System.out.print(split2[i] + " ");
//        }
//        test054();
//        test052();
//        test052_2();
//        String aa = "23G2M33T";
//        // 根据字母M或G或T进行分割
//        String[] split = aa.split("[M|G|T]");
//        for (String s : split) {
//            System.out.println(s);
//        }
//        System.out.println(split.length);
//        // 根据1个或多个数字进行分割
//        String[] split2 = aa.split("[0-9]+");
//        for (String s : split2) {
//            System.out.println(s);
//        }
//        String s2 = "12skj34kjf34sjfks";
//        // 根据1个或多个字母进行分割
//        String[] split3 = s2.split("[a-z|A-Z]+");
//        for (String s : split3) {
//            System.out.println(s);
//        }
//        System.out.println(split3.length);

//        char a = 1;
//        char b = 'a';
//        char c = 'z';
//        System.out.println(b > a);
//        System.out.println(b > a);
//        System.out.println(c > b);
//
//        String line = "aaaaaa44ko543j123j7345677781";
//        String[] split = line.split("[a-z|A-Z]+");
//        for (String s : split) {
//            System.out.println(s);
//        }
//        test051();
//        test051_2();
//        test050();
//        test048();
//        test048_2();
//        String ss = "abcd";
//        String ss1 = "ddd";
//        for (int k = 0; k < ss.length(); k++) {
//            if (ss1.contains(ss.charAt(k) + "")) {
//                System.out.println(ss.charAt(k));
//            }
//        }

//        String line = "!ekam a ekekac";
//        String[] split = line.split(" ");
//        for (int i = 0; i < split.length; i++) {
//            String str = split[i];
//            // 若单词中包含如数字等其他非字母时不进行反转
//            if (str.replaceAll("[a-z|A-Z]", "").length() == 0) {
//                String newStr = "";
//                for (int j = 0; j < str.length(); j++) {
//                    newStr = str.charAt(j) + newStr;
//                }
//                str = newStr;
//            }
//            System.out.println(str);
//        }
//        test047();
//        test047_2();
//        test046();
//        String newLine = "7#6$5#126$5";
//        String newLine2 = "";
//        int mun = 25;
//        newLine2 = newLine.replaceFirst("//$", mun + "");
//        System.out.println(newLine2);

//        String line = "7#6$5#126$5";
//        String[] sign = line.split("[0-9]+");
//        List<String> signList = new ArrayList<>();
//        for (int i = 1; i < sign.length; i++) {
//            signList.add(sign[i]);
//        }
//        String[] nums = line.split("[$|#]+");
//
//        for (int i = 0; i < signList.size(); i++){
//            System.out.print(signList.get(i) + " ");
//        }
//        System.out.println();
//        for (String s : nums){
//            System.out.print(s + " ");
//        }

//        test046();

//        String s = Integer.toBinaryString(100);
//        System.out.println(s);

//        test043();
//        test043_2();

//        String s = Integer.toHexString(45);
//        System.out.println(s);
//        System.out.println(s.toUpperCase());

        // 任何进制数转10进制，第一个参数：要转的字符串； 第二个参数：要转的字符串的进制数
//        int parseInt = Integer.parseInt("110", 2);
//        // 十进制转二进制
//        String s = Integer.toBinaryString(123);
//        // 十进制转十六进制,十六进制的字母是小写的
//        String s1 = Integer.toHexString(123);
//        // 字符串小写字母转大写
//        String upperCase = s1.toUpperCase();
//        // 字符串大写字母转小写
//        String lowerCase = s1.toLowerCase();
//        System.out.println(parseInt);
//        System.out.println(s);
//        System.out.println(s1);
//        System.out.println(upperCase);
//        System.out.println(lowerCase);

//        test042();

//        test040();
//        test040_2();
//        test039();
//        test039_2();
        test038();
//        test038_2();
    }

    /**
     * 给定一个随机的整数数组(可能存在正整数和负整数)nums,
     * 请你在该数组中找出两个数，其和的绝对值(|nums[x]+nums[y]|)为最小值
     * 并返回这两个数(按从小到大返回)以及绝对值。
     * 每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。
     * <p>
     * 输入描述：
     * 一个通过空格空格分割的有序整数序列字符串，最多1000个整数，
     * 且整数数值范围是[-65535,65535]
     * <p>
     * 输出描述：
     * 两个数和两数之和绝对值
     * <p>
     * 示例一：
     * 输入
     * -1 -3 7 5 11 15
     * 输出
     * -3 5 2
     * <p>
     * 说明：
     * 因为|nums[0]+nums[2]|=|-3+5|=2最小，
     * 所以返回-3 5 2
     */
    public static void test068() {
        Scanner sc = new Scanner(System.in);
        String line = sc.nextLine();
        String[] split = line.split(" ");
        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < split.length; i++) {
            int parseInt = Integer.parseInt(split[i]);
            if (!list.contains(parseInt)) {
                list.add(parseInt);
            }
        }
        int minRes = Integer.MAX_VALUE;
        for (int i = 0; i < list.size() - 1; i++) {
            for (int j = i + 1; j < list.size(); j++) {
                minRes = Math.min(minRes, Math.abs(list.get(i) + list.get(j)));
            }
        }
        for (int i = 0; i < list.size() - 1; i++) {
            Integer numi = list.get(i);
            for (int j = i + 1; j < list.size(); j++) {
                Integer numj = list.get(j);
                if (minRes == Math.abs(numi + numj)) {
                    if (numi > numj) {
                        System.out.println(numj + " " + numi + " " + minRes);
                    } else {
                        System.out.println(numi + " " + numj + " " + minRes);
                    }
                    return;
                }
            }
        }
    }


    /**
     * 题目描述：
     * 给定一个字符串s，最多只能进行一次变换，返回变换后能得到的最小字符串（按照字典序进行比较）。
     * 变换规则：交换字符串中任意两个不同位置的字符。
     * 输入描述：
     * 一串小写字母组成的字符串s。
     * 输出描述：
     * 按照要求进行变换得到的最小字符串。
     * 备注：
     * s是都是小写字符组成
     * 1<=s.length<=1000
     * 示例
     * 输入：abcdef
     * <p>
     * 输出：abcdef
     * <p>
     * 说明：abcdef已经是最小字符串，不需要交换
     * <p>
     * <p>
     * 输入：bcdefa
     * <p>
     * 输出：acdefb
     * <p>
     * 说明：a和b进行位置交换，可以得到最小字符串
     */
    public static void test067() {
        Scanner sc = new Scanner(System.in);
        char[] chars = sc.nextLine().toCharArray();
        for (int j = 0; j < chars.length; j++) {
            char minValue = chars[j];
            int minIndex = j;
            for (int i = j; i < chars.length; i++) {
                if (chars[i] <= minValue) {
                    minValue = chars[i];
                    minIndex = i;
                }
            }
            if (minIndex != j) {
                chars[minIndex] = chars[j];
                chars[j] = minValue;
                System.out.println(new String(chars));
                return;
            }
        }
    }


    /**
     * 定义当一个字符串只有元音字母(a,e,i,o,u,A,E,I,O,U)组成,
     * 称为元音字符串，现给定一个字符串，请找出其中最长的元音字符串，
     * 并返回其长度，如果找不到请返回0，
     * 字符串中任意一个连续字符组成的子序列称为该字符串的子串
     * <p>
     * 输入描述：
     * 一个字符串其长度 0<length ,字符串仅由字符a-z或A-Z组成
     * 输出描述：
     * 一个整数，表示最长的元音字符子串的长度
     * <p>
     * 示例1：
     * 输入
     * asdbuiodevauufgh
     * 输出
     * 3
     * 说明：
     * 最长的元音字符子串为uio和auu长度都为3，因此输出3
     */
    public static void test066() {
        Scanner sc = new Scanner(System.in);
        char[] chars = sc.nextLine().toCharArray();
        List<Character> list = new ArrayList<>();
        list.add('a');
        list.add('e');
        list.add('i');
        list.add('o');
        list.add('u');
        list.add('A');
        list.add('E');
        list.add('I');
        list.add('O');
        list.add('U');
        int maxLen = 0;
        int tempLen = 0;
        for (int i = 0; i < chars.length; i++) {
            while (i < chars.length && list.contains(chars[i])) {
                i++;
                tempLen++;
            }
            maxLen = Math.max(maxLen, tempLen);
            tempLen = 0;
        }
        System.out.println(maxLen);
    }

    /**
     * 输入一个由N个大小写字母组成的字符串
     * 按照ASCII码值从小到大进行排序
     * 查找字符串中第K个最小ASCII码值的字母(k>=1)
     * 输出该字母所在字符串中的位置索引(字符串的第一个位置索引为0)
     * k如果大于字符串长度则输出最大ASCII码值的字母所在字符串的位置索引
     * 如果有重复字母则输出字母的最小位置索引
     * <p>
     * 输入描述
     * 第一行输入一个由大小写字母组成的字符串
     * 第二行输入k k必须大于0 k可以大于输入字符串的长度
     * <p>
     * 输出描述
     * 输出字符串中第k个最小ASCII码值的字母所在字符串的位置索引
     * k如果大于字符串长度则输出最大ASCII码值的字母所在字符串的位置索引
     * 如果第k个最小ASCII码值的字母存在重复  则输出该字母的最小位置索引
     * <p>
     * 示例一
     * 输入
     * AbCdeFG
     * 3
     * 输出
     * 5
     * 说明
     * 根据ASCII码值排序，第三个ASCII码值的字母为F
     * F在字符串中位置索引为5(0为字符串的第一个字母位置索引)
     * <p>
     * 示例二
     * 输入
     * fAdDAkBbBq
     * 4
     * 输出
     * 6
     * 说明
     * 根据ASCII码值排序前4个字母为AABB由于B重复则只取B的第一个最小位置索引6
     * 而不是第二个B的位置索引8
     */
    public static void test065() {
        Scanner sc = new Scanner(System.in);
        String line = sc.nextLine();
        char[] chars = line.toCharArray();
        int index = sc.nextInt();
        int length = chars.length;
        List<Character> list = new ArrayList<>();
        for (int i = 0; i < length; i++) {
            list.add(chars[i]);
        }
        Collections.sort(list);
        if (index > length) {
//            for (int i = 0; i < length; i++) {
//                if (chars[i] == list.get(length - 1)) {
//                    System.out.println(i);
//                    return;
//                }
//            }
            System.out.println(line.indexOf(list.get(length - 1)));
        } else {
//        for (int i = 0; i < length; i++) {
//            if (chars[i] == list.get(index - 1)) {
//                System.out.println(i);
//                return;
//            }
            System.out.println(line.indexOf(list.get(index - 1)));
//        }
        }
    }

    public static void test065_2() {
        Scanner in = new Scanner(System.in);
        String line = in.nextLine();
        int k = in.nextInt();
        in.close();

        char[] chars = line.toCharArray();
        ArrayList<Character> list = new ArrayList<>();
        for (char aChar : chars) {
            list.add(aChar);
        }

        list.sort(Character::compareTo);
        char c = k >= list.size() ? list.get(list.size() - 1) : list.get(k - 1);
        System.out.println(line.indexOf(c));
    }

    /**
     * 绘图机器的绘图笔初始位置在原点(0,0)
     * 机器启动后按照以下规则来进行绘制直线
     * 1. 尝试沿着横线坐标正向绘制直线
     * 直到给定的终点E
     * 2. 期间可以通过指令在纵坐标轴方向进行偏移
     * offsetY为正数表示正向偏移,为负数表示负向偏移
     * <p>
     * 给定的横坐标终点值E 以及若干条绘制指令
     * 请计算绘制的直线和横坐标轴以及x=E的直线组成的图形面积
     * 输入描述:
     * 首行为两个整数N 和 E
     * 表示有N条指令,机器运行的横坐标终点值E
     * 接下来N行 每行两个整数表示一条绘制指令x offsetY
     * 用例保证横坐标x以递增排序的方式出现
     * 且不会出现相同横坐标x
     * 取值范围:
     * 0<N<=10000
     * 0<=x<=E<=20000
     * -10000<=offsetY<=10000
     * <p>
     * 输出描述:
     * 一个整数表示计算得到的面积 用例保证结果范围在0到4294967295之内
     * 示例1:
     * 输入:
     * 4 10
     * 1 1
     * 2 1
     * 3 1
     * 4 -2
     * 输出:
     * 12
     * <p>
     * 示例2:
     * 输入:
     * 2 4
     * 0 1
     * 2 -2
     * 输出:
     * 4
     */
    // 这个通过率好像只有95%，没有具体的测试数据，我也不知道哪里有问题
    public static void test064() {
        Scanner sc = new Scanner(System.in);
        String line1 = sc.nextLine();
        String[] split1 = line1.split(" ");
        int num = Integer.parseInt(split1[0]);
        int end = Integer.parseInt(split1[1]);
        List<Integer> listX = new ArrayList<>();
        List<Integer> listY = new ArrayList<>();
        for (int i = 0; i < num; i++) {
            String line = sc.nextLine();
            String[] split = line.split(" ");
            listX.add(Integer.parseInt(split[0]));
            listY.add(Integer.parseInt(split[1]));
        }
        int sumY = 0;
        int sumArea = 0;
        for (int i = 0; i < num; i++) {
            if (i == num - 1) {
                sumY += listY.get(i);
                sumArea += (end - listX.get(i)) * Math.abs(sumY);
            } else {
                sumY += listY.get(i);
                sumArea += (listX.get(i + 1) - listX.get(i)) * Math.abs(sumY);
            }
        }
        System.out.println(sumArea);
    }

    public static void test064_2() {
        Scanner in = new Scanner(System.in);
        String[] split = in.nextLine().split(" ");
        int N = Integer.parseInt(split[0]);
        int E = Integer.parseInt(split[1]);

        int curX = 0, curY = 0, area = 0;

        for (int i = 0; i < N; i++) {
            String[] strs = in.nextLine().split(" ");
            int x = Integer.parseInt(strs[0]);
            int y = Integer.parseInt(strs[1]);

            area += (x - curX) * Math.abs(curY);

            curX = x;
            curY += y;
        }
        if (curX < E) {
            area += (E - curX) * Math.abs(curY);
        }

        System.out.println(area);
        in.close();
    }

    /**
     * 给定两个字符集合
     * 一个是全量字符集
     * 一个是已占用字符集
     * 已占用字符集中的字符不能再使用
     * 要求输出剩余可用字符集
     * <p>
     * 输入描述
     * 1. 输入一个字符串 一定包含@
     *
     * @前为全量字符集 @后的为已占用字符集
     * 2. 已占用字符集中的字符
     * 一定是全量字符集中的字符
     * 字符集中的字符跟字符之间使用英文逗号隔开
     * 3. 每个字符都表示为字符+数字的形式
     * 用英文冒号分隔
     * 比如a:1标识一个a字符
     * 4. 字符只考虑英文字母，区分大小写
     * 数字只考虑正整型 不超过100
     * 5. 如果一个字符都没被占用 @标识仍存在
     * 例如 a:3,b:5,c:2@
     * <p>
     * 输出描述：
     * 输出可用字符集
     * 不同的输出字符集之间用回车换行
     * 注意 输出的字符顺序要跟输入的一致
     * 不能输出b:3,a:2,c:2
     * 如果某个字符已全部占用 则不需要再输出
     * <p>
     * 示例一：
     * 输入
     * a:3,b:5,c:2@a:1,b:2
     * 输出
     * a:2,b:3,c:2
     * 说明：
     * 全量字符集为三个a，5个b，2个c
     * 已占用字符集为1个a，2个b
     * 由于已占用字符不能再使用
     * 因此剩余可用字符为2个a，3个b，2个c
     * 因此输出a:2,b:3,c:2
     */
    // 如果全量字符中有重复的，是相加还是取最后一个？？ 我做的是相加，如果取最后一个则先remove，在put，就能保证插入顺序
    public static void test063() {
        Scanner sc = new Scanner(System.in);
        String line = sc.nextLine();
        String[] split = line.split("@");
        if (line.charAt(line.length() - 1) == '@') {
            System.out.println(line.substring(0, line.length() - 1));
            return;
        }
        String[] allString = split[0].split(",");
        String[] userString = split[1].split(",");
        // linkedHashMap 按插入顺序排列， HashMap按key值字典排序
        Map<String, Integer> map = new LinkedHashMap<>();
        for (int i = 0; i < allString.length; i++) {
            String[] strAndNum = allString[i].split(":");
            String str = strAndNum[0];
            int num = Integer.parseInt(strAndNum[1]);
            if (map.containsKey(str)) {
                map.put(str, map.get(str) + num);
            } else {
                map.put(str, num);
            }
        }
        for (int i = 0; i < userString.length; i++) {
            String[] strAndNum = userString[i].split(":");
            String str = strAndNum[0];
            int num = Integer.parseInt(strAndNum[1]);
            map.put(str, map.get(str) - num);
        }
        StringBuilder sb = new StringBuilder();
        for (String s : map.keySet()) {
            if (map.get(s) > 0) {
                sb.append(s + ":" + map.get(s) + ",");
            }
        }
        System.out.println(sb.substring(0, sb.length() - 1));
    }

    public static void test063_2() {
        Scanner in = new Scanner(System.in);
        String[] split = in.nextLine().split("@");
        in.close();

        HashMap<String, Info> map = new HashMap<>();

        String[] all = split[0].split(",");
        for (int i = 0; i < all.length; i++) {
            String[] char_count = all[i].split(":");
            String c = char_count[0];
            map.put(c, new Info(c, i, Integer.parseInt(char_count[1])));
        }

        if (split.length > 1)
            for (String s : split[1].split(",")) {
                String[] char_count = s.split(":");
                String c = char_count[0];
                Info value = map.get(c);
                value.count -= Integer.parseInt(char_count[1]);
                map.put(c, value);
            }

        StringBuilder sb = new StringBuilder();

        map.values().stream().filter(x -> x.count > 0)
                .sorted(new Comparator<Info>() {
                    @Override
                    public int compare(Info o1, Info o2) {
                        return o1.no - o2.no;
                    }
                }).forEach(x ->
                sb.append(x.c)
                        .append(":")
                        .append(x.count)
                        .append(","));

        System.out.println(sb.substring(0, sb.length() - 1));
    }

    public static class Info {

        public String c;
        public int no;
        public int count;

        public Info(String c, int no, int count) {
            this.c = c;
            this.no = no;
            this.count = count;
        }

    }

    /**
     * 给你两个字符串t和p
     * 要求从t中找到一个和p相同的连续子串
     * 并输出该子串第一个字符的下标
     * 输入描述
     * 输入文件包括两行 分别表示字符串t和p
     * 保证t的长度不小于p
     * 且t的长度不超过1000000
     * p的长度不超过10000
     * 输出描述
     * 如果能从t中找到一个和p相等的连续子串,
     * 则输出该子串第一个字符在t中的下标
     * 下标从左到右依次为1,2,3,...；
     * 如果不能则输出 "No"
     * 如果含有多个这样的子串
     * 则输出第一个字符下标最小的
     * <p>
     * 示例一：
     * 输入：
     * AVERDXIVYERDIAN
     * RDXI
     * 输出
     * 4
     */
    public static void test061() {
        Scanner sc = new Scanner(System.in);
        String t = sc.nextLine();
        String p = sc.nextLine();
        for (int i = 0; i < t.length(); i++) {
            int start = i;
            int j = 0;
            while (start < t.length() && j < p.length() && t.charAt(start) == p.charAt(j)) {
                start++;
                j++;
            }
            if (j == p.length()) {
                System.out.println(i + 1);
                return;
            }
        }
        System.out.println("No");
    }

    public static void test061_2() {
        Scanner in = new Scanner(System.in);
        String t = in.nextLine();
        String p = in.nextLine();
        in.close();

        int len = p.length();

        for (int i = 0; i <= t.length() - len; i++) {
            String substring = t.substring(i, i + len);
            if (substring.equals(p)) {
                System.out.println(i + 1);
                return;
            }
        }
        System.out.println("No");
    }

    /**
     * 游戏规则：
     * 输入一个只包含英文字母的字符串,
     * 字符串中的两个字母如果相邻且相同,就可以消除。
     * 在字符串上反复执行消除的动作,
     * 直到无法继续消除为止,此时游戏结束。
     * 输出最终得到的字符串长度.
     * <p>
     * 输入描述：
     * 输入原始字符串str
     * 只能包含大小写英文字母,字母的大小写敏感,
     * str长度不超过100
     * <p>
     * 输出描述
     * 输出游戏结束后,最终得到的字符串长度
     * <p>
     * 示例一：
     * 输入
     * gg
     * <p>
     * 输出
     * 0
     * 说明 gg可以直接消除 得到空串 长度为0
     * <p>
     * 示例2
     * 输入：
     * mMbccbc
     * 输出
     * 3
     * 说明mMbccbc中 可以先消除cc 此时变为mMbbc
     * 再消除 bb 此时变成mMc
     * 此时没有相同且相邻的字符 无法继续消除
     * 最终得到字符串mMc  长度为3
     * <p>
     * 备注：
     * 输入中包含非大小写英文字母时
     * 均为异常输入
     * 直接返回0
     */
    // 与69相同，跳过
    public static void test060() {
        Scanner in = new Scanner(System.in);
        String line = in.nextLine();
        in.close();

        if (line.replaceAll("[a-zA-Z]", "")
                .length() > 0) {
            System.out.println(0);
            return;
        }

        LinkedList<Character> link = new LinkedList<>();
        for (char c : line.toCharArray()) {
            link.add(c);
        }
        for (int i = 0; i < link.size() - 1; ) {
            if (link.get(i).equals(link.get(i + 1))) {
                link.remove(i);
                link.remove(i);
                i--;
                i = Math.max(i, 0);
            } else {
                i++;
            }
        }

        System.out.println(link.size());
    }

    /**
     * 公司用一个字符串来标识员工的出勤信息
     * <p>
     * absent:    缺勤
     * late:      迟到
     * leaveearly:早退
     * present:   正常上班
     * <p>
     * 现需根据员工出勤信息,判断本次是否能获得出勤奖,
     * 能获得出勤奖的条件如下：
     * 1.缺勤不超过1次
     * 2.没有连续的迟到/早退
     * 3.任意连续7次考勤 缺勤/迟到/早退 不超过3次
     * <p>
     * 输入描述：
     * 用户的考勤数据字符串记录条数  >=1
     * 输入字符串长度 <10000 ;
     * 不存在非法输入
     * 如：
     * 2
     * present
     * present absent present present leaveearly present absent
     * <p>
     * 输出描述：
     * 根据考勤数据字符串
     * 如果能得到考勤奖输出true否则输出false
     * 对于输出示例的结果应为
     * true false
     * <p>
     * 示例一：
     * 输入：
     * 2
     * present
     * present present
     * <p>
     * 输出：
     * true true
     * <p>
     * 示例二
     * 输入：
     * 2
     * present
     * present absent present present leaveearly present absent
     * 输出：
     * true false
     */
    public static void test059() {
        Scanner sc = new Scanner(System.in);
        int num = Integer.parseInt(sc.nextLine());
        List<String> list = new ArrayList<>();
        for (int i = 0; i < num; i++) {
            String line = sc.nextLine();
            list.add(line);
        }
        for (int i = 0; i < list.size(); i++) {
            String str = list.get(i);
            String[] split = str.split(" ");
            // 1.缺勤不超过1次
            int absentCount = 0;
            for (int j = 0; j < split.length; j++) {
                if ("absent".equals(split[j])) {
                    absentCount++;
                }
            }
            if (absentCount > 1) {
                System.out.print(false + " ");
                continue;
            }
            // 2.没有连续的迟到/早退
            if (str.contains("late leaveearly") || str.contains("leaveearly late") || str.contains("leaveearly leaveearly") || str.contains("late late")) {
                System.out.print(false + " ");
                continue;
            }
            // 3.任意连续7次考勤 缺勤/迟到/早退 不超过3次
            int count = 0;
            int noPresent = 0;
            if (split.length > 7) {
                for (int j = 0; j + 7 <= split.length; j++) {
                    for (int k = j; k < 7 + j; k++) {
                        if ("absent".equals(split[k]) || "late".equals(split[k]) || "leaveearly".equals(split[k])) {
                            noPresent++;
                        }
                    }
                    count = Math.max(count, noPresent);
                    noPresent = 0;
                }
            } else {
                for (int j = 0; j < split.length; j++) {
                    if ("absent".equals(split[j]) || "late".equals(split[j]) || "leaveearly".equals(split[j])) {
                        count++;
                    }
                }
            }
            if (count > 3) {
                System.out.print(false + " ");
                continue;
            }
            System.out.print(true + " ");
        }
    }

    /**
     * 一个工厂有m条流水线
     * 来并行完成n个独立的作业
     * 该工厂设置了一个调度系统
     * 在安排作业时，总是优先执行处理时间最短的作业
     * 现给定流水线个数m
     * 需要完成的作业数n
     * 每个作业的处理时间分别为 t1,t2...tn
     * 请你编程计算处理完所有作业的耗时为多少
     * 当n>m时 首先处理时间短的m个作业进入流水线
     * 其他的等待
     * 当某个作业完成时，
     * 依次从剩余作业中取处理时间最短的
     * 进入处理
     * <p>
     * 输入描述：
     * 第一行为两个整数(采取空格分隔)
     * 分别表示流水线个数m和作业数n
     * 第二行输入n个整数(采取空格分隔)
     * 表示每个作业的处理时长 t1,t2...tn
     * 0<m,n<100
     * 0<t1,t2...tn<100
     * <p>
     * 输出描述
     * 输出处理完所有作业的总时长
     * <p>
     * 案例
     * 输入
     * 3 5
     * 8 4 3 2 10
     * 输出
     * 13
     * 说明
     * 先安排时间为2,3,4的三个作业
     * 第一条流水线先完成作业
     * 调度剩余时间最短的作业8
     * 第二条流水线完成作业
     * 调度剩余时间最短的作业10
     * 总共耗时 就是二条流水线完成作业时间13(3+10)
     * <p>
     * 3 9
     * 1 1 1 2 3 4 6 7 8
     */
    public static void test058() {
        Scanner sc = new Scanner(System.in);
        String line1 = sc.nextLine();
        String line2 = sc.nextLine();
        String[] split1 = line1.split(" ");
        // 线个数m和作业数n
        int m = Integer.parseInt(split1[0]);
        int n = Integer.parseInt(split1[1]);
        String[] split2 = line2.split(" ");
        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < split2.length; i++) {
            list.add(Integer.parseInt(split2[i]));
        }
        Collections.sort(list);
        if (n <= m) {
            System.out.println(list.get(list.size() - 1));
            return;
        }
        List<Integer> resList = new ArrayList<>();
        for (int k = 0; k < m; k++) {
            int allTime = 0;
            for (int i = k; i < list.size(); i += m) {
                allTime += list.get(i);
            }
            resList.add(allTime);
        }
        Collections.sort(resList);
        System.out.println(resList.get(resList.size() - 1));
    }

    public static void test058_2() {
        Scanner in = new Scanner(System.in);
        String[] strs = in.nextLine().split(" ");
        int m = Integer.parseInt(strs[0]);
        int n = Integer.parseInt(strs[1]);

        String[] split = in.nextLine().split(" ");
        int[] jobs = new int[split.length];
        for (int i = 0; i < split.length; i++) {
            jobs[i] = Integer.parseInt(split[i]);
        }
        Arrays.sort(jobs);

        if (n <= m) {
            System.out.println(jobs[jobs.length - 1]);
            return;
        }

        ArrayList<Integer> res = new ArrayList<>();

        for (int i = 0; i < m; i++) {
            res.add(jobs[i]);
        }

        for (int i = m; i < jobs.length; i++) {
            Integer min = new ArrayList<>(new TreeSet<>(res)).get(0);
            int index = res.indexOf(min);
            res.set(index, res.get(index) + jobs[i]);
        }

        ArrayList<Integer> r = new ArrayList<>(new TreeSet<>(res));

        System.out.println(r.get(r.size() - 1));
    }

    /**
     * 给定一个字符串
     * 只包含大写字母
     * 求在包含同一字母的子串中
     * 长度第K长的子串
     * 相同字母只取最长的子串
     * <p>
     * 输入
     * 第一行 一个子串 1<len<=100
     * 只包含大写字母
     * 第二行为k的值
     * <p>
     * 输出
     * 输出连续出现次数第k多的字母的次数
     * <p>
     * 例子：
     * 输入
     * AABAAA
     * 2
     * 输出
     * 1
     * 同一字母连续出现最多的A 3次
     * 第二多2次  但A出现连续3次
     * <p>
     * 输入
     * <p>
     * AAAAHHHBBCDHHHH
     * 3
     * <p>
     * 输出
     * 2
     * <p>
     * //如果子串中只包含同一字母的子串数小于k
     * <p>
     * 则输出-1
     */
    // 与17一样
    public static void test057() {

    }

    /**
     * 为了充分发挥Gpu算力，
     * 需要尽可能多的将任务交给GPU执行，
     * 现在有一个任务数组，
     * 数组元素表示在这1s内新增的任务个数，
     * 且每秒都有新增任务，
     * 假设GPU最多一次执行n个任务，
     * 一次执行耗时1s，
     * 在保证Gpu不空闲的情况下，最少需要多长时间执行完成。
     * <p>
     * 输入描述
     * 第一个参数为gpu最多执行的任务个数
     * 取值范围1~10000
     * 第二个参数为任务数组的长度
     * 取值范围1~10000
     * 第三个参数为任务数组
     * 数字范围1~10000
     * <p>
     * 输出描述
     * 执行完所有任务需要多少秒
     * <p>
     * 例子
     * 输入
     * 3
     * 5
     * 1 2 3 4 5
     * 输出
     * 6
     * <p>
     * 说明，一次最多执行3个任务  最少耗时6s
     * <p>
     * 例子2
     * 输入
     * 4
     * 5
     * 5 4 1 1 1
     * 输出
     * 5
     * <p>
     * 说明，一次最多执行4个任务  最少耗时5s
     */
    // 跟第五题一样
    public static void test056() {
        Scanner sc = new Scanner(System.in);
        int qps = Integer.parseInt(sc.nextLine());
        int num = Integer.parseInt(sc.nextLine());
        String line = sc.nextLine();
        String[] split = line.split(" ");

        int leaveTask = 0;
        int time = 0;
        for (int i = 0; i < num; i++) {
            int taskNum = Integer.parseInt(split[i]);
            if (taskNum + leaveTask <= qps) {
                time++;
                leaveTask = 0;
            } else {
                time++;
                leaveTask = taskNum + leaveTask - qps;
            }
        }
        if (leaveTask > 0) {
            time += leaveTask / qps;
        }
        if (leaveTask % qps != 0) {
            time++;
        }
        System.out.println(time);
    }

    /**
     * 单词接龙的规则是
     * 可用于接龙的单词首字母必须要与前一个单词的尾字母相同
     * 当存在多个首字母相同的单词时
     * 取长度最长的单词
     * 如果长度也相等则取词典序最小的单词
     * 已经参与接龙的单词不能重复使用
     * 现给定一组全部由小写字母组成的单词数组
     * 并指定其中的一个单词为起始单词
     * 进行单词接龙
     * 请输出最长的单词串
     * 单词串是由单词拼接而成 中间没有空格
     * <p>
     * 输入描述：
     * 输入的第一行为一个非负整数
     * 表示起始单词在数组中的索引k  0<=k<=n
     * 第二行输入的是一个非负整数表示单词的个数n
     * 接下来的n行分别表示单词数组中的单词
     * <p>
     * 输出描述：
     * 输出一个字符串表示最终拼接的字符串
     * <p>
     * 示例1：
     * 输入
     * 0
     * 6
     * word
     * dd
     * da
     * dc
     * dword
     * d
     * <p>
     * 输出
     * worddwordda
     * <p>
     * 说明：
     * 先确定起始单词word
     * 再确定d开头长度最长的单词dword
     * 剩余以d开头且长度最长的由 da dd dc
     * 则取字典序最小的da
     * 所以最后输出worddwordda
     * <p>
     * 示例二：
     * 输入：
     * 4
     * 6
     * word
     * dd
     * da
     * dc
     * dword
     * d
     * 输出：
     * dwordda
     */
    // 与14题一样
    public static void test055() {
        Scanner in = new Scanner(System.in);
        int k = Integer.parseInt(in.nextLine());
        int n = Integer.parseInt(in.nextLine());
        ArrayList<String> words = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            words.add(in.nextLine());
        }
        in.close();

        StringBuilder builder = new StringBuilder();
        builder.append(words.get(k));
        words.remove(k);

        words.sort(new Comparator<String>() {
            @Override
            public int compare(String w1, String w2) {
                int len1 = w1.length();
                int len2 = w2.length();
                if (len1 != len2) {
                    return len2 - len1;
                } else {
                    return w1.compareTo(w2);
                }
            }
        });

        int len;
        do {
            len = builder.length();
            String last = builder.substring(builder.length() - 1);
            for (int i = 0; i < words.size(); i++) {
                String cur = words.get(i);
                if (cur.startsWith(last)) {
                    builder.append(cur);
                    words.remove(cur);
                    break;
                }
            }
        } while (builder.length() != len);

        System.out.println(builder.toString());
    }

    // PS：如果给出的单词中同样的单词出现两次，能用两次还是用一次？我这里是用了两次，如果只能用一次的话，可以用一个list来存储用过的单词，如果在里面，就不用
    // 单词接龙
    public static void test055_2() {
        Scanner sc = new Scanner(System.in);
        int start = Integer.parseInt(sc.nextLine());
        int len = Integer.parseInt(sc.nextLine());
        List<String> list = new ArrayList<>();
        for (int i = 0; i < len; i++) {
            list.add(sc.nextLine());
        }
        String startWord = list.get(start);
        // 移除起始元素
        list.remove(startWord);
        list.sort((s1, s2) -> {
            int length1 = s1.length();
            int length2 = s2.length();
            if (length1 != length2) {
                return length2 - length1;
            }
            // 按照字典排序，遍历每一个字符，返回不相同字符的差值
            return s1.compareTo(s2);
        });
        String result = startWord;
        for (int i = 0; i < list.size(); i++) {
            String value = list.get(i);
            if (getStartOrEnd(startWord, 100).equals(getStartOrEnd(value, 1))) {
                result = result + value;
                // 找到的单词作为起始单词
                startWord = value;
                // 移除用过的单词
                list.remove(value);
                // 找到了归零，下一个从头开始找
                i = 0;
            }
        }
        System.out.println(result);
    }

    private static String getStartOrEnd(String key, int num) {
        // 求字符串首字母
        if (num == 1) {
            return key.substring(0, 1);
        } else { // 求字符串尾字幕
            return key.substring(key.length() - 1, key.length());
        }
    }

    /**
     * 输入一个英文文章片段
     * 翻转指定区间的单词顺序，标点符号和普通字母一样处理
     * 例如输入字符串 "I am a developer."
     * 区间[0,3]则输出 "developer. a am I"
     * <p>
     * 输入描述：
     * 使用换行隔开三个参数
     * 第一个参数为英文文章内容即英文字符串
     * 第二个参数为反转起始单词下标，下标从0开始
     * 第三个参数为结束单词下标，
     * <p>
     * 输出描述
     * 反转后的英文文章片段，所有单词之间以一个半角空格分割进行输出
     * <p>
     * 示例一：
     * 输入
     * I am a developer.
     * 1
     * 2
     * 输出
     * I a am developer.
     * <p>
     * 示例二：
     * 输入
     * Hello world!
     * 0
     * 1
     * 输出
     * world! Hello
     * <p>
     * 说明：
     * 输入字符串可以在前面或者后面包含多余的空格，
     * 但是反转后的不能包含多余空格
     * <p>
     * 示例三：
     * 输入：
     * I am a developer.
     * 0
     * 3
     * 输出
     * developer. a am I
     * <p>
     * 说明：
     * 如果两个单词见有多余的空格
     * 将反转后单词间的空格减少到只含一个
     * <p>
     * 示例四：
     * 输入
     * Hello!
     * 0
     * 3
     * 输出
     * EMPTY
     * <p>
     * 说明：
     * 指定反转区间只有一个单词，或无有效单词则统一输出EMPTY
     */
    // 与7题一样
    public static void test054() {
        Scanner sc = new Scanner(System.in);
        String line = sc.nextLine();
        int start = sc.nextInt();
        int end = sc.nextInt();
        // 去掉前后的空格
        line = line.trim();
        String[] split = line.split(" ");
        // 如果起始数小于0，取0
        start = Math.max(start, 0);
        // 如果结束数大于数组长度，取数组最后一个
        end = Math.min(end, split.length - 1);
        // 指定反转区间只有一个单词，或无有效单词则统一输出EMPTY
        if (start >= end || start >= split.length - 1 || end <= 0) {
            System.out.println("EMPTY");
            return;
        }
        // 进行字符串翻转，直至重合
        while (start < end) {
            String temp = split[start];
            split[start] = split[end];
            split[end] = temp;
            start++;
            end--;
        }
        //拼接字符串
        StringBuilder sb = new StringBuilder();
        for (String s : split) {
            sb.append(s + " ");
        }
        // 去掉末尾的空格
        System.out.println(sb.toString().trim());
    }


    /**

     */
    // 53题已经做了
    public static void test053() {

    }

    /**
     * 磁盘的容量单位有M,G,T这三个等级
     * 他们之间的换算关系为
     * 1T=1024G
     * 1G=1024M
     * 现在给定N块磁盘的容量
     * 请对他们按从小到大的顺序进行稳定排序
     * 例如给定5块盘容量
     * 1T,20M,3G,10G6T,3M12G9M
     * 排序后的结果为20M,3G,3M12G9M,1T,10G6T
     * <p>
     * 注意单位可以重复出现
     * 上述3M12G9M为 3M+12G+9M和 12M12G相等
     * <p>
     * 输入描述:
     * 输入第一行包含一个整数N
     * 2<=N<=100 ,表示磁盘的个数
     * 接下来的N行每行一个字符串 长度 (2<l<30)
     * 表示磁盘的容量
     * 有一个或多个格式为 mv的子串组成
     * 其中m表示容量大小 v表示容量单位
     * 例如
     * <p>
     * 磁盘容量m的范围 1~1024正整数
     * 容量单位v的范围包含题目中提到的M,G,T
     * <p>
     * 输出描述:
     * 输出N行
     * 表示N块磁盘容量排序后的结果
     * <p>
     * 示例1:
     * 输入
     * 3
     * 1G
     * 2G
     * 1024M
     * <p>
     * 输出
     * 1G
     * 1024M
     * 2G
     * <p>
     * 说明 1G和1024M容量相等,稳定排序要求保留他们原来的相对位置
     * 故1G在1024M前
     * <p>
     * 示例二:
     * 输入
     * 3
     * 2G4M
     * 3M2G
     * 1T
     * <p>
     * 输出
     * 3M2G
     * 2G4M
     * 1T
     * 说明1T大于2G4M大于3M2G
     */
    public static void test052_2() {
        Scanner sc = new Scanner(System.in);
        int len = Integer.parseInt(sc.nextLine());
        List<String> list = new ArrayList<>();
        for (int i = 0; i < len; i++) {
            list.add(sc.nextLine());
        }
        list.sort((s1, s2) -> {
            // 复杂的写法，使用双层循环分别求出每个数字和字母
            char[] chars1 = s1.toCharArray();
            char[] chars2 = s2.toCharArray();
            // 使用long型防止int型不够用
            long allNum1 = 0;
            long allNum2 = 0;
            for (int i = 0; i < chars1.length; i++) {
                String num = "";
                // 判断是否是数字->获得字母前的数字
                while (i < chars1.length && Character.isDigit(chars1[i])) {
                    // 拼接数字
                    num = num + chars1[i];
                    i++;
                }
                if (chars1[i] == 'M') {
                    allNum1 += Integer.parseInt(num);
                } else if (chars1[i] == 'G') {
                    allNum1 += Integer.parseInt(num) * 1024;
                } else {
                    allNum1 += Integer.parseInt(num) * 1024 * 1024;
                }
            }
            for (int i = 0; i < chars2.length; i++) {
                String num = "";
                // 判断是否是数字->获得字母前的数字
                while (i < chars2.length && Character.isDigit(chars2[i])) {
                    // 拼接数字
                    num = num + chars2[i];
                    i++;
                }
                if (chars2[i] == 'M') {
                    allNum2 += Integer.parseInt(num);
                } else if (chars2[i] == 'G') {
                    allNum2 += Integer.parseInt(num) * 1024;
                } else {
                    allNum2 += Integer.parseInt(num) * 1024 * 1024;
                }
            }
            // 比较两个long型数据，x > y 返回1，x < y返回-1，x = y返回0
            return Long.compare(allNum1, allNum2);
        });
        for (String s : list) {
            System.out.println(s);
        }
    }

    // 巧妙的解法
    public static void test052() {
        Scanner sc = new Scanner(System.in);
        int len = Integer.parseInt(sc.nextLine());
        List<String> list = new ArrayList<>();
        for (int i = 0; i < len; i++) {
            list.add(sc.nextLine());
        }
        // 对数组进行排序
        list.sort((s1, s2) -> {
            long num1 = toNumber(s1);
            long num2 = toNumber(s2);
            // 比较两个long型数据，x > y 返回1，x < y返回-1，x = y返回0
            return Long.compare(num1, num2);
        });
        for (String s : list) {
            System.out.println(s);
        }
    }

    /**
     * 将字符串转为具体多少M，返回一个long型数字
     *
     * @return
     */
    private static long toNumber(String s) {
        // 正则表达式：根据字母M或G或T进行分割
        String[] numArray = s.split("[M|G|T]"); // 结果[1,2,3]
        // 正则表达式：根据1个或多个数字进行分割
        String[] letterArray = s.split("[0-9]+"); // 结果[,M,T,G] 因为字符串以数字开头，所以数组第一个是空
        // 返回的结果
        long sum = 0;
        for (int i = 1; i < letterArray.length; i++) {
            String letter = letterArray[i];
            long num = Long.parseLong(numArray[i - 1]);
            if ("M".equals(letter)) {
                sum += num;
            } else if ("G".equals(letter)) {
                sum += 1024 * num;
            } else if ("T".equals(letter)) {
                sum += 1024 * 1024 * num;
            }
        }
        return sum;
    }

    /**
     * 输入一个字符串仅包含大小写字母和数字
     * 求字符串中包含的最长的非严格递增连续数字序列长度
     * 比如：
     * 12234属于非严格递增数字序列
     * 示例：
     * 输入
     * abc2234019A334bc
     * 输出
     * 4
     * 说明：
     * 2234为最长的非严格递增连续数字序列，所以长度为4
     * <p>
     * 输入
     * aaaaaa44ko543j123j7345677781
     * 输出
     * 8
     * <p>
     * 输入
     * aaaaa34567778a44ko543j123j71
     * 输出
     * 8
     * <p>
     * 输入
     * 345678a44ko543j123j7134567778aa
     * 输出
     * 9
     * <p>
     * 输入
     * fwefksoSKJF12S45DS3DSAJKSldsf565441345sd1f87151234657812154341543
     * 输出
     * 5
     */
    public static void test051() {
        Scanner sc = new Scanner(System.in);
        String line = sc.nextLine();
        String[] split = line.split("[a-z|A-Z]+");
        int res = 0;
        for (int i = 0; i < split.length; i++) {
            String letters = split[i];
            int sum = 0;
            for (int j = 0; j < letters.length(); j++) {
                int partSum = 1;
                while (j + 1 < letters.length() && letters.charAt(j) <= letters.charAt(j + 1)) {
                    partSum++;
                    j++;
                }
                sum = Math.max(sum, partSum);
            }
            res = Math.max(res, sum);
        }
        System.out.println(res);
    }

    // 高效解法
    public static void test051_2() {
        Scanner sc = new Scanner(System.in);
        String line = sc.nextLine();
        char[] chars = line.toCharArray();
        // 当前非严格递增长度
        int currentLen = 0;
        // 非严格递增最大长度
        int maxLen = 0;
        // 上一个字符，默认一个比数字大的
        char last = 'a';
        for (char c : chars) {
            if (Character.isDigit(c)) { // 当前字符是数字
                if (currentLen == 0) { // 当数字是开头时
                    currentLen++;
                } else if (c >= last) { // 符合非严格递增，当前非严格递增长度长度
                    currentLen++;
                } else { // 不符合非严格递增，保留最大的非严格递增长度
                    maxLen = Math.max(currentLen, maxLen);
                    // 初始化当前严格递增长度,因为当前是数字，所以其本身长度是1
                    currentLen = 1;
                }
                // 将当前数字置为上一个，用于比较
                last = c;
            } else { // 当前字符不是数字
                // 保留最大的非严格递增长度
                maxLen = Math.max(maxLen, currentLen);
                // 初始化当前严格递增长度
                currentLen = 0;
                // 初始化上一个字符
                last = 'a';
            }
        }
        System.out.println(maxLen);
    }

    /**
     * 小明从糖果盒中随意抓一把糖果
     * 每次小明会取出一半的糖果分给同学们
     * 当糖果不能平均分配时
     * 小明可以从糖果盒中(假设盒中糖果足够)取出一个或放回一个糖果
     * 小明至少需要多少次(取出放回和平均分配均记一次)能将手中糖果分至只剩一颗
     * <p>
     * 输入描述：
     * 抓取糖果数(小于1000000)：15
     * 输出描述：
     * 最少分至一颗糖果的次数：5
     * <p>
     * 示例1：
     * 输入
     * 15
     * 输出
     * 5
     * 备注
     * 解释：(1) 15+1=16;
     * (2) 16/2=8;
     * (3) 8/2=4;
     * (4) 4/2=2;
     * (5) 2/2=1;
     */
    // 这道题通过率好像只有85%，我也不知道原因
    public static void test050() {
        Scanner sc = new Scanner(System.in);
        int num = sc.nextInt();
        int count = 0;
        while (num != 1) {
            // 当num=3时，无论加1还是减1，都是原基础次数加上2，所以可以直接返回
            if (num == 3) {
                System.out.println(count + 2);
                return;
            }
            // 当num不是偶数
            if (num % 2 != 0) {
                // 当(num + 1) / 2 % 2 == 0 说明num+1后除以2还是偶数，所以选择+1，否则-1
                if ((num + 1) / 2 % 2 == 0) {
                    num++;
                } else {
                    num--;
                }
                // 无论是+1还是-1，count都要累加1
                count++;
            } else { // 当nums是偶数，除以2，count累加1
                num /= 2;
                count++;
            }
        }
        System.out.println(count);
    }

    /**

     */
    // 与12题一样
    public static void test049() {

    }

    /**
     * 给定一个元素类型为小写字符串的数组
     * 请计算两个没有相同字符的元素长度乘积的最大值
     * 如果没有符合条件的两个元素返回0
     * <p>
     * 输入描述
     * 输入为一个半角逗号分割的小写字符串数组
     * 2<= 数组长度 <=100
     * 0< 字符串长度 <=50
     * 输出描述
     * 两个没有相同字符的元素长度乘积的最大值
     * <p>
     * 示例一
     * 输入
     * iwdvpbn,hk,iuop,iikd,kadgpf
     * 输出
     * 14
     * 说明
     * 数组中有5个元组  第一个和第二个元素没有相同字符
     * 满足条件 输出7*2=14
     */
    public static void test048() {
        Scanner sc = new Scanner(System.in);
        String line = sc.nextLine();
        String[] split = line.split(",");
        int sum = 0;
        for (int i = 0; i < split.length; i++) {
            for (int j = i + 1; j < split.length; j++) {
                boolean flag = true;
                String first = split[i];
                String next = split[j];
                for (int k = 0; k < first.length(); k++) {
                    if (next.contains(first.charAt(k) + "")) {
                        flag = false;
                        break;
                    }
                }
                if (flag) {
                    sum = Math.max(sum, first.length() * next.length());
                }
            }
        }
        System.out.println(sum);
    }

    public static void test048_2() {
        Scanner in = new Scanner(System.in);
        String line = in.nextLine();
        in.close();

        String[] strings = line.split(",");

        int max = 0;
        for (int i = 0; i < strings.length; i++) {
            for (int j = i; j < strings.length; j++) {
                char[] chars = strings[j].toCharArray();
                int k = 0;
                while (k < chars.length) {
                    if (strings[i].indexOf(chars[k]) != -1) break;
                    k++;
                }
                int tmp = strings[i].length() * strings[j].length();
                if (k == chars.length && tmp > max) max = tmp;
            }
        }

        System.out.println(max);

    }

    /**
     * 相对开音节构成的结构为辅音+元音(aeiou)+辅音(r除外)+e
     * 常见的单词有bike cake
     * 给定一个字符串，以空格为分隔符
     * 反转每个单词的字母
     * 若单词中包含如数字等其他非字母时不进行反转
     * 反转后计算其中含有相对开音节结构的子串个数
     * (连续子串中部分字符可以重复)
     * <p>
     * 输入描述
     * 字符串 以空格分割的多个单词
     * 长度<10000 字母只考虑小写
     * <p>
     * 输出描述
     * 含有相对开音节结构的子串个数
     * <p>
     * 示例1：
     * 输入
     * ekam a ekac
     * 输出
     * 2
     * 说明：
     * 反转后为  make a cake 其中make和cake为相对开音节子串
     * 返回2
     * <p>
     * 示例2：
     * 输入
     * !ekam a ekekac
     * 输出
     * 2
     * 说明
     * 反转后为 !ekam a cakeke
     * 因为!ekam含有非英文字母，所以未反转
     * 其中 cake和keke 为相对开音节子串 返回2
     */
    public static void test047() {
        Scanner sc = new Scanner(System.in);
        String line = sc.nextLine();
        String[] split = line.split(" ");
        int count = 0;
        for (int i = 0; i < split.length; i++) {
            String str = split[i];
            // 若单词中包含如数字等其他非字母时不进行反转
            if (str.replaceAll("[a-z]", "").length() == 0) {
                String newStr = "";
                for (int j = 0; j < str.length(); j++) {
                    newStr = str.charAt(j) + newStr;
                }
                str = newStr;
            }

            for (int k = 0; k < str.length() - 3; k++) {
                // 辅音+元音(aeiou)+辅音(r除外)+e
                if (!"aeiou".contains(str.charAt(k) + "")
                        && "aeiou".contains(str.charAt(k + 1) + "")
                        && !"aeiour".contains(str.charAt(k + 2) + "")
                        && 'e' == str.charAt(k + 3)) {
                    count++;
                }
            }
        }
        System.out.println(count);
    }

    public static void test047_2() {
        Scanner in = new Scanner(System.in);
        String line = in.nextLine();
        in.close();

        String[] words = line.split(" ");

        int count = 0;

        for (String word : words) {
            char[] chars = word.toCharArray();
            if (word.replaceAll("[a-z]+", "").isEmpty()) {
                for (int i = 0, j = chars.length - 1; i < j; i++, j--) {
                    char tmp = chars[i];
                    chars[i] = chars[j];
                    chars[j] = tmp;
                }
            }
            if (chars.length < 4) continue;
            for (int i = 0; i < chars.length - 3; i++) {
                if (!isVowel(chars[i])
                        && isVowel(chars[i + 1])
                        && !isVowel(chars[i + 2]) && chars[i + 2] != 'r'
                        && chars[i + 3] == 'e') {
                    count++;
                }
            }
        }

        System.out.println(count);
    }

    private static boolean isVowel(char c) {
        return c == 'a' || c == 'e' || c == 'i'
                || c == 'o' || c == 'u';
    }

    /**
     * 已知火星人使用的运算符号为#;$
     * 其与地球人的等价公式如下
     * x#y=2*x+3*y+4
     * x$y=3*x+y+2
     * x y是无符号整数
     * 地球人公式按照c语言规则进行计算
     * 火星人公式中$符优先级高于# 相同的运算符按从左到右的顺序运算
     * <p>
     * 输入描述：
     * 火星人字符串表达式结尾不带回车换行
     * 输入的字符串说明是 字符串为仅有无符号整数和操作符组成的计算表达式
     * <p>
     * 1.用例保证字符串中操作数与操作符之间没有任何分隔符
     * 2.用例保证操作数取值范围为32位无符号整数，
     * 3.保证输入以及计算结果不会出现整型溢出
     * 4.保证输入的字符串为合法的求值报文
     * 例如: 123#4$5#76$78
     * 5.保证不会出现非法的求值报文
     * 例如: #4$5 这种缺少操作数
     * 4$5#  这种缺少操作数
     * 4#$5  这种缺少操作数
     * 4 $5  有空格
     * 3+4-5*6/7 有其他操作符
     * 12345678987654321$54321 32位整数溢出
     * <p>
     * 输出描述：
     * 根据火星人字符串输出计算结果
     * 结尾不带回车换行
     * <p>
     * 案例1：
     * 输入：
     * 7#6$5#12
     * 输出：
     * 226
     * <p>
     * 说明 示例7#6$5#12=7#(3*6+5+2)#12
     * =7#25#12
     * =(2*7+3*25+4)#12
     * =93#12
     * =2*93+3*12+4
     * =226
     */
    public static void test046() {
        // x#y=2*x+3*y+4
        // x$y=3*x+y+2
        // 7#6$5#12
        Scanner sc = new Scanner(System.in);
        String line = sc.nextLine();
        String[] sign = line.split("[0-9]+");
        List<String> signList = new ArrayList<>();
        for (int i = 1; i < sign.length; i++) {
            signList.add(sign[i]);
        }
        String[] nums = line.split("[$|#]+");
        List<Integer> numsList = new ArrayList();
        for (int i = 0; i < nums.length; i++) {
            numsList.add(Integer.parseInt(nums[i]));
        }

        while (signList.indexOf("$") != -1) {
            int index$ = signList.indexOf("$");
            int sum = calculation$(numsList.get(index$), numsList.get(index$ + 1));
            numsList.set(index$, sum);
            numsList.remove(index$ + 1);
            signList.remove(index$);
        }
        int res = numsList.get(0);
        for (int i = 1; i < numsList.size(); i++) {
            res = calculation(res, numsList.get(i));
        }
        System.out.println(res);
    }

    /**
     * x$y=3*x+y+2
     *
     * @param num1
     * @param num2
     * @return
     */
    private static int calculation$(int num1, int num2) {
        return 3 * num1 + num2 + 2;
    }

    /**
     * x#y=2*x+3*y+4
     *
     * @param num1
     * @param num2
     * @return
     */
    private static int calculation(int num1, int num2) {
        return 2 * num1 + 3 * num2 + 4;
    }

    /**
     * 实现一个整数编码方法
     * 使得待编码的数字越小
     * 编码后所占用的字节数越小
     * 编码规则如下
     * 1.编码时7位一组，每个字节的低7位用于存储待编码数字的补码
     * 2.字节的最高位表示后续是否还有字节，置1表示后面还有更多的字节，
     * 置0表示当前字节为最后一个字节
     * 3.采用小端序编码，低位和低字节放在低地址上
     * 4.编码结果按16进制数的字符格式进行输出，小写字母需要转化为大写字母
     * <p>
     * 输入描述
     * 输入的为一个字符串表示的非负整数
     * 输出描述
     * 输出一个字符串表示整数编码的16进制码流
     * <p>
     * 示例一
     * 输入
     * 0
     * 输出
     * 00
     * 说明：输出的16进制字符不足两位的前面补零
     * <p>
     * 示例二
     * 输入
     * 100
     * 输出
     * 64
     * 说明:100的二进制表示为0110 0100只需一个字节进行编码
     * 字节的最高位0，剩余7位存储数字100的低7位(1100100)所以编码后的输出为64
     * <p>
     * 示例三
     * 输入
     * 1000
     * 输出
     * E807
     * 说明
     * 1000的二进制表示为 0011 1110 1000 至少需要两个字节进行编码
     * 第一个字节最高位是1 剩余7位存储数字 1000的低7位(1101000)
     * 所以第一个字节的二进制位(1110 1000)即E8
     * 第二个字节最高位置0 剩余的7位存储数字 1000的第二个低7位(0000111)
     * 所以第一个字节的二进制为(0000 0111)即07
     * 采用小端序编码 所以低字节E8输出在前面
     * 高字节07输出在后面
     * <p>
     * 备注
     * 代编码数字取值范围为 [0,1<<64-1]
     */
    // 小端序编码 大概意思就是原来低位放在高位，高位放在低位，就是颠倒过来。在这里的意思就是低位转的放在前面，越高位转的放在越后面(可能理解有误)
    // 代码通过率没有100%，自己的测试数据都能过，暂不知道原因，能看出异常的请告诉我！！！
    public static void test043() {
        Scanner sc = new Scanner(System.in);
        int input = sc.nextInt();
        String binaryValue = Integer.toBinaryString(input);
        int len = binaryValue.length();
        if (len <= 7) {
            int parseInt = Integer.parseInt("0" + binaryValue, 2);
            System.out.println(tenTo16(parseInt));
            return;
        }
        int count = len / 7;
        String res = "";
        for (int i = 0; i < count; i++) {
            int num = 0;
            String lastStr = binaryValue.substring(len - 7 * (i + 1), len - 7 * i);
            if (i == count - 1) {
                if (len % 7 == 0) {
                    // 0
                    num = Integer.parseInt("0" + lastStr, 2);
                } else {
                    // 1
                    num = Integer.parseInt("1" + lastStr, 2);
                }

            } else {
                // 1
                num = Integer.parseInt("1" + lastStr, 2);
            }
            res = res + tenTo16(num);
        }
        if (len % 7 != 0) {
            int numTen = Integer.parseInt(binaryValue.substring(0, len - 7 * count), 2);
            String s = tenTo16(numTen);
            res = res + s;
        }
        System.out.println(res);
    }

    /**
     * 十进制转十六进制
     *
     * @return
     */
    private static String tenTo16(int num) {
        String s = "";
        do {
            int res = num % 16;
            num = num / 16;
            if (res == 15) {
                s = "F" + s;
            } else if (res == 14) {
                s = "E" + s;
            } else if (res == 13) {
                s = "D" + s;
            } else if (res == 12) {
                s = "C" + s;
            } else if (res == 11) {
                s = "B" + s;
            } else if (res == 10) {
                s = "A" + s;
            } else {
                s = res + s;
            }
        } while (num != 0);
        if (s.length() == 1) {
            return "0" + s;
        }
        return s;
    }

    /**
     * 任何进制转10进制
     * 十进制转二进制
     * 十进制转十六进制
     */
    public void study() {
        // 任何进制数转10进制，第一个参数：要转的字符串； 第二个参数：要转的字符串的进制数
        int parseInt = Integer.parseInt("110", 2);
        // 十进制转二进制
        String s = Integer.toBinaryString(123);
        // 十进制转十六进制,十六进制的字母是小写的
        String s1 = Integer.toHexString(123);
        // 字符串小写字母转大写
        String upperCase = s1.toUpperCase();
        // 字符串大写字母转小写
        String lowerCase = s1.toLowerCase();
    }

    public static void test043_2() {
        Scanner in = new Scanner(System.in);
        int num = Integer.parseInt(in.nextLine());
        in.close();

        String binary = Integer.toBinaryString(num);

        int len = binary.length();

        StringBuilder sb = new StringBuilder();
        for (int i = len; i > 0; i -= 7) {
            int start = Math.max(i - 7, 0);

            String bin = binary.substring(start, i);

            if (bin.length() < 7) {
                StringBuilder head = new StringBuilder();
                for (int j = 0; j < 7 - bin.length(); j++) {
                    head.append("0");
                }
                bin = head.append(bin).toString();
            }
            bin = i - 7 <= 0 ? "0" + bin : "1" + bin;
            String hex = Integer.toHexString(Integer.parseInt(bin, 2)).toUpperCase();
            if (hex.length() == 1) hex = "0" + hex;
            sb.append(hex);
        }

        System.out.println(sb);
    }

    /**
     * Vlan是一种为局域网设备进行逻辑划分的技术
     * 为了标识不同的vlan 引入了vlan id 1~4094之间的整数
     * 定义一个vlan id 的资源池
     * 资源池中连续的vlan用开始vlan-结束vlan表示，
     * 不连续的用单个整数表示
     * 所有的vlan用英文逗号连接起来
     * 现有一个vlan资源池，业务需要从资源池中申请一个vlan
     * 需要你输出从vlan资源池中移除申请的vlan后的资源池
     * <p>
     * 输入描述
     * 第一行为字符串格式的vlan资源池
     * 第二行为业务要申请的vlan vlan的取值范围1~4094
     * <p>
     * 输出描述
     * 从输入vlan资源池中移除申请的vlan后
     * 字符串格式的vlan资源池
     * 输出要求满足题目中要求的格式，
     * 并且要求从小到大升序输出
     * 如果申请的vlan不在原资源池，输出升序排序的原资源池的字符串即可
     * <p>
     * 示例一
     * 输入
     * 1-5
     * 2
     * 输出
     * 1,3-5
     * 说明：原vlan资源池中有1 2 3 4 5 移除2后
     * 剩下的1 3 4 5按照升序排列的方式为 1 3-5
     * <p>
     * 示例二
     * 输入
     * 20-21,15,18,30,5-10
     * 15
     * 输出
     * 5-10,18,20-21,30
     * 说明：
     * 原vlan资源池中有5 6 7 8 9 10 15 18 20 21 30
     * 移除15后 剩下的为 5 6 7 8 9 10 18 20 21 30
     * 按照题目描述格式并升序后的结果为5-10,18,20-21,30
     * <p>
     * 示例三
     * 输入
     * 5,1-3
     * 10
     * 输出
     * 1-3,5
     * 资源池中有1 2 3 5
     * 申请的资源不在资源池中
     * 将原池升序输出为1-3,5
     * <p>
     * 输入池中vlan数量范围为2~2094的整数
     * 资源池中vlan不重复且合法1~2094的整数
     * 输入是乱序的
     */
    public static void test042() {
        Scanner sc = new Scanner(System.in);
        String line = sc.nextLine();
        int num = sc.nextInt();
        String[] split = line.split(",");
        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < split.length; i++) {
            String str = split[i];
            if (str.contains("-")) {
                String[] split1 = str.split("-");
                int start = Integer.parseInt(split1[0]);
                int end = Integer.parseInt(split1[1]);
                for (int j = start; j <= end; j++) {
                    list.add(j);
                }
            } else {
                list.add(Integer.parseInt(str));
            }
        }
        boolean flag = list.remove((Integer) num);
        Collections.sort(list);
        List<String> resList = new ArrayList<>();
        for (int i = 0; i < list.size(); i++) {
            int start = i;
            while (i + 1 < list.size() && list.get(i) + 1 == list.get(i + 1)) {
                i++;
            }
            if (start == i) {
                resList.add(list.get(start) + "");
            } else {
                resList.add(list.get(start) + "-" + list.get(i));
            }
        }

        for (int i = 0; i < resList.size(); i++) {
            if (i == resList.size() - 1) {
                System.out.print(resList.get(i));
            } else {
                System.out.print(resList.get(i) + ",");
            }
        }
    }

    /**
     * 给定参数n 从1到n会有n个整数 1，2，3，...n
     * 这n个数字共有n!种排列 按大小顺序升序列出所有排列情况
     * 并一一标记
     * 当n=3时，所有排列如下
     * "123","132","213","231","312","321"
     * 给定n和k 返回第n个排列
     * <p>
     * 输入描述
     * 第一行为n
     * 第二行为k
     * n的范围是 1~9
     * k的范围是 1~n!
     * <p>
     * 输出描述
     * 输出排列第k位置的数字
     * <p>
     * 示例一：
     * 输入
     * 3
     * 3
     * 输出
     * 213
     * <p>
     * 示例二:
     * 输入
     * 2
     * 2
     * 输出
     * 21
     */
    // 跟80题一样 TODO
    static TreeSet<String> set = new TreeSet<>();

    public static void test041() {
        Scanner in = new Scanner(System.in);
        int n = Integer.parseInt(in.nextLine());
        int k = Integer.parseInt(in.nextLine());
        in.close();
        Integer[] arr = new Integer[n];
        for (int i = 0; i < n; i++) {
            arr[i] = i + 1;
        }
        perm(arr, 0, n - 1);
        String res = new ArrayList<>(set).get(k - 1);
        System.out.println(res);
    }

    public static void perm(Integer[] array, int start, int end) {

        if (start == end) {
            String num = Arrays.toString(array).replaceAll("\\W+", "");
            set.add(num);
        } else {
            for (int i = start; i <= end; i++) {
                swap(array, start, i);
                perm(array, start + 1, end);
                swap(array, start, i);
            }
        }
    }

    public static void swap(Integer[] array, int i, int j) {
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }

    /**
     * 幼儿园两个班的小朋友排队时混在了一起
     * 每个小朋友都知道自己跟前面一个小朋友是不是同班
     * 请你帮忙把同班的小朋友找出来
     * 小朋友的编号为整数
     * 与前面一个小朋友同班用Y表示
     * 不同班用N表示
     * 输入描述：
     * 输入为空格分开的小朋友编号和是否同班标志
     * 比如 6/N 2/Y 3/N 4/Y
     * 表示一共有4位小朋友
     * 2和6是同班 3和2不同班 4和3同班
     * 小朋友总数不超过999
     * 0< 每个小朋友编号 <999
     * 不考虑输入格式错误
     * <p>
     * 输出两行
     * 每一行记录一班小朋友的编号  编号用空格分开
     * 并且
     * 1. 编号需要按照大小升序排列，分班记录中第一个编号小的排在第一行
     * 2. 如果只有一个班的小朋友 第二行为空
     * 3. 如果输入不符合要求输出字符串ERROR
     * <p>
     * 示例：
     * 输入
     * 1/N 2/Y 3/N 4/Y
     * 输出
     * 1 2
     * 3 4
     * 说明：2的同班标记为Y因此和1同班
     * 3的同班标记位N因此和1,2不同班
     * 4的同班标记位Y因此和3同班
     */
    public static void test040() {
        Scanner sc = new Scanner(System.in);
        String line = sc.nextLine();
        Map<Integer, String> map = new LinkedHashMap<>();
        try {
            String[] split = line.split(" ");
            for (int i = 0; i < split.length; i++) {
                String str = split[i];
                String[] split1 = str.split("/");
                if (i == 0 && "Y".equals(split1[1])) {
                    System.out.println("ERROR");
                    return;
                }
                if ((!"N".equals(split1[1]) && !"Y".equals(split1[1])) || map.containsKey(Integer.parseInt(split1[0]))) {
                    System.out.println("ERROR");
                    return;
                }
                map.put(Integer.parseInt(split1[0]), split1[1]);
            }
            List<Integer> list1 = new ArrayList<>();
            List<Integer> list2 = new ArrayList<>();
            list1.add(Integer.parseInt(line.substring(0, line.indexOf("/"))));
            boolean flag = true;
            boolean remove = map.remove(Integer.parseInt(line.substring(0, line.indexOf("/"))), "N");
            for (Integer s : map.keySet()) {
                if (flag) {
                    if ("Y".equals(map.get(s))) {
                        list1.add(s);
                        flag = true;
                    } else {
                        list2.add(s);
                        flag = false;
                    }
                } else {
                    if ("Y".equals(map.get(s))) {
                        list2.add(s);
                        flag = false;
                    } else {
                        list1.add(s);
                        flag = true;
                    }

                }
            }
            Collections.sort(list1);
            Collections.sort(list2);
            for (int k = 0; k < list1.size(); k++) {
                System.out.print(list1.get(k) + " ");
            }
            System.out.println();
            for (int k = 0; k < list2.size(); k++) {
                System.out.print(list2.get(k) + " ");
            }

        } catch (Exception e) {
            System.out.println("ERROR");
            return;
        }

    }

    public static void test040_2() {
        Scanner in = new Scanner(System.in);
        String[] stus = in.nextLine().split(" ");
        in.close();

        try {

            TreeSet<Integer> c1 = new TreeSet<>();
            TreeSet<Integer> c2 = new TreeSet<>();

            boolean is1 = true;
            for (int i = 0; i < stus.length; i++) {
                String[] split = stus[i].split("/");
                String id = split[0];
                String same = split[1];
                if (i == 0) {
                    c1.add(Integer.parseInt(id));
                    continue;
                }
                if ("N".equals(same)) is1 = !is1;
                (is1 ? c1 : c2).add(Integer.parseInt(id));
            }

            StringBuilder b1 = new StringBuilder();
            for (Integer id : c1) b1.append(id).append(" ");

            if (c2.size() > 0) {
                StringBuilder b2 = new StringBuilder();
                for (Integer id : c2) b2.append(id).append(" ");
                if (c1.first() < c2.first()) {
                    System.out.println(b1.toString().trim());
                    System.out.println(b2.toString().trim());
                } else {
                    System.out.println(b2.toString().trim());
                    System.out.println(b1.toString().trim());
                }
            } else {
                System.out.println(b1.toString().trim());
            }

        } catch (Exception e) {
            System.out.println("ERROR");
        }

    }

    /**
     * 有一个数列A[n]
     * 从A[0]开始每一项都是一个数字
     * 数列中A[n+1]都是A[n]的描述
     * 其中A[0]=1
     * 规则如下
     * A[0]:1
     * A[1]:11 含义其中A[0]=1是1个1 即11
     * 表示A[0]从左到右连续出现了1次1
     * A[2]:21 含义其中A[1]=11是2个1 即21
     * 表示A[1]从左到右连续出现了2次1
     * A[3]:1211 含义其中A[2]从左到右是由一个2和一个1组成 即1211
     * 表示A[2]从左到右连续出现了一次2又连续出现了一次1
     * A[4]:111221  含义A[3]=1211 从左到右是由一个1和一个2两个1 即111221
     * 表示A[3]从左到右连续出现了一次1又连续出现了一次2又连续出现了2次1
     * <p>
     * 输出第n项的结果
     * 0<= n <=59
     * 输入描述：
     * 数列第n项   0<= n <=59
     * 4
     * 输出描述
     * 数列内容
     * 111221
     */
    public static void test039() {
        Scanner sc = new Scanner(System.in);
        int num = sc.nextInt();
        if (num == 0) {
            System.out.println(0);
            return;
        }
        String s = "1";
        StringBuilder sb = new StringBuilder();
        for (int i = 1; i <= num; i++) {
            char[] chars = s.toCharArray();
            for (int j = 0; j < chars.length; j++) {
                int start = j;
                while (j + 1 < chars.length && chars[j] == chars[j + 1]) {
                    j++;
                }
                if (start == j) {
                    sb.append(1).append(chars[j]);
                } else {
                    sb.append(j - start + 1).append(chars[j]);
                }
            }
            s = sb.toString();
            sb = new StringBuilder();
        }
        System.out.println(s);
    }

    /**
     * 给定一个url前缀和url后缀
     * 通过,分割 需要将其连接为一个完整的url
     * 如果前缀结尾和后缀开头都没有/
     * 需要自动补上/连接符
     * 如果前缀结尾和后缀开头都为/
     * 需要自动去重
     * 约束：
     * 不用考虑前后缀URL不合法情况
     * <p>
     * 输入描述
     * url前缀(一个长度小于100的字符串)
     * url后缀(一个长度小于100的字符串)
     * 输出描述
     * 拼接后的url
     * <p>
     * 一、
     * 输入
     * /acm,/bb
     * 输出
     * /acm/bb
     * <p>
     * 二、
     * 输入
     * /abc/,/bcd
     * 输出
     * /abc/bcd
     * <p>
     * 三、
     * 输入
     * /acd,bef
     * 输出
     * /acd/bef
     * <p>
     * 四、
     * 输入
     * ,
     * 输出
     * /
     */
    // 这道题默认
    public static void test038() {
        Scanner sc = new Scanner(System.in);
        String line = sc.nextLine();
        String[] split = line.split(",");
        if (split.length <= 0) {
            System.out.println("/");
            return;
        }
        // 前面为空
        if (line.indexOf(",") == 0) {
            if (line.contains("/")) {
                System.out.println(split[1]);
                return;
            } else {
                System.out.println("/" + split[1]);
                return;
            }
        }
        // 后面为空
        if (line.indexOf(",") == line.length() - 1) {
            if (split[0].charAt(split[0].length() - 1) == '/') {
                System.out.println(split[0].substring(0, split[0].length() - 1));
                return;
            } else {
                System.out.println(split[0]);
                return;
            }
        }

        if (split[0].charAt(split[0].length() - 1) == '/') {
            split[0] = split[0].substring(0, split[0].length() - 1);
        }
        if (split[1].charAt(split[1].length() - 1) == '/') {
            split[1] = split[1].substring(0, split[1].length() - 1);
        }
        if (split[0].charAt(0) != '/') {
            split[0] = "/" + split[0];
        }
        if (split[1].charAt(0) != '/') {
            split[1] = "/" + split[1];
        }
        System.out.println(split[0] + split[1]);
    }

    public static void test038_2() {
        Scanner in = new Scanner(System.in);
        String line = in.nextLine();
        in.close();

        String[] split = line.split(",");
        if (split.length == 0) {
            System.out.println("/");
            return;
        }

        String combine = split[0] + "/" + split[1];
        String url = combine.replaceAll("/+", "/");
        System.out.println(url);
    }

}



